package com.cmas.platform.utils;

import com.aidex.common.core.domain.R;
import com.aidex.common.exception.CustomException;
import com.baidu.aip.contentcensor.AipContentCensor;
import com.baidu.aip.contentcensor.EImgType;
import com.github.houbb.sensitive.word.bs.SensitiveWordBs;
import org.json.JSONArray;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * @Author su
 * @Date 2023/4/14 16:37
 */
@Component
public class ContentCheckUtil {

    @Autowired
    private SensitiveWordBs sensitiveWordBs;


    /**
     * 百度文本审核，识别审核结果的JSON KEY
     */
    public static final String CENSOR_CONCLUSION_TYPE_KEY = "conclusionType";
    public static final String CENSOR_CONCLUSION_ERROR = "error_code";
    public static final String CENSOR_CONCLUSION = "conclusion";
    public static final String CENSOR_CONCLUSION_DATA = "data";


    /**
     * 正常状态
     */
    public static final Integer CENSOR_SUCCESS = 1;

    /**
     * Ai审核不通过
     */
    public static final Integer CENSOR_FAIL = 2;

    /**
     * Ai审核疑似不通过
     */
    public static final Integer CENSOR_SUSPECT = 3;

    /**
     * Ai审核错误
     */
    public static final Integer CENSOR_ERROR = 4;


    @Autowired
    private AipContentCensor aipContentCensor;

    /**
     * 初始化Bean   类加@Component
     */
    public static ContentCheckUtil contentCheckUtil = new ContentCheckUtil();


    @PostConstruct
    public void init() {
        contentCheckUtil.sensitiveWordBs = sensitiveWordBs;
        contentCheckUtil.aipContentCensor = aipContentCensor;
    }


    /**
     * 获取照片审核结果
     *
     * @param imageUrl 图片Url
     * @return 百度图片审核JSON
     */
    public R<?> getImageCensorResult(String imageUrl) {
        //如果内容为空，则直接返回
        if (imageUrl == null || imageUrl.isEmpty()) {
            return R.fail("图片地址为空");
        }
        try {
            return getCensorResult(contentCheckUtil.aipContentCensor.imageCensorUserDefined(imageUrl, EImgType.URL, null));
        } catch (Exception e) {
            e.printStackTrace();
            throw new CustomException("请求失败：" + e.getMessage());
        }
    }


    /**
     * 获取常规文本审核结果
     *
     * @param content 内容
     * @return 百度内容审核JSON
     */
    public static R<Integer> getCommonTextCensorResult(String content) {
        //如果内容为空，则直接返回
        if (content == null || content.isEmpty()) {
            return R.fail("内容为空");
        }
        try {
            return getCensorResult(contentCheckUtil.aipContentCensor.textCensorUserDefined(content));
        } catch (Exception e) {
            e.printStackTrace();
            throw new CustomException("请求失败：" + e.getMessage());
        }
    }


    /**
     * 获取审核结果
     *
     * @param clientJsonObject 百度审核的JSON字段
     * @return 审核结果
     */
    private static R<Integer> getCensorResult(JSONObject clientJsonObject) {
        //获取代表审核结果的字段
        //审核结果类型，可取值1.合规，2.不合规，3.疑似，4.审核失败
        int conclusionType;
        //返回数据
        R<Integer> result = new R<>();
        //错误消息
        String message = "";
        //如果是null就直接判定为失败
        if (clientJsonObject == null || clientJsonObject.has(CENSOR_CONCLUSION_ERROR)) {
            conclusionType = CENSOR_ERROR;
            message = "审核失败";
        } else {
            conclusionType = clientJsonObject.getInt(CENSOR_CONCLUSION_TYPE_KEY);
            if (clientJsonObject.has(CENSOR_CONCLUSION_DATA)) {
                message = messageByCensorResultDate(clientJsonObject.getJSONArray(CENSOR_CONCLUSION_DATA));
            } else {
                message = clientJsonObject.getString(CENSOR_CONCLUSION);
            }
        }
        result.setMsg(message);
        result.setData(conclusionType);
        result.setCode(R.SUCCESS);
        return result;
    }

    /**
     * 获得描述信息
     *
     * @param data
     * @return
     */
    private static String messageByCensorResultDate(JSONArray data) {
        StringBuilder message = new StringBuilder();
        for (int i = 0; i < data.length(); i++) {
            if (i != data.length() - 1) message.append(data.getJSONObject(i).get("msg")).append(",");
            else message.append(data.getJSONObject(i).get("msg"));
        }
        return message.toString();
    }


    //敏感词内容审核
    public static R<?> checkBySensitiveWord(String content) {
        if (contentCheckUtil.sensitiveWordBs.contains(content)) {
            return R.fail("包含敏感信息，请修改后发布！敏感词为:"+ contentCheckUtil.sensitiveWordBs.findAll(content));
        }
        return R.success();
    }

    /**
     * 更新词库
     * <p>
     * 每次数据库的信息发生变化之后，首先调用更新数据库敏感词库的方法。
     * 如果需要生效，则调用这个方法。
     * <p>
     * 说明：重新初始化不影响旧的方法使用。初始化完成后，会以新的为准。
     */
    public static void refresh() {
        // 每次数据库的信息发生变化之后，首先调用更新数据库敏感词库的方法，然后调用这个方法。
        contentCheckUtil.sensitiveWordBs.init();
    }


}
